Method Detail

• clip

  public static boolean clip(DatasetVector dataset,
                             DatasetVector clipDataset,
                             DatasetVector resultDataset,
                             OverlayAnalystParameter parameter)

  Crop the vector dataset and crop and delete the objects that are not in the cropped dataset (the second dataset) in the cut data set (the first dataset). Note:

  1. The type of the cropped dataset (the second dataset) must be a face, and the reduced data set (first dataset) can be a point, a line, a face.
  2. In the cut data set, only objects that fall within the clipping dataset polygon are output to the result dataset.
  3. Crop the dataset, the geographic coordinates of the data set and the resulting dataset must be consistent.
  4. clip and intersect are consistent in space processing, the difference is that the result of the record set attribute processing, clip analysis is used to do the cut, the result records and the first record set of the same property table structure, where the superposition Analysis parameter object setting is invalid. And the result of intersecting transitions can preserve the fields of the two recordsets according to the field setting.
  5. All overlay results do not take into account the system fields of the dataset.

  

  Parameters:

  dataset - A reduced data set, also called a first dataset. The type of the data set can be points, lines, and faces.

  clipDataset - The data set used for cropping, also called the second dataset. The dataset type must be surface.

  resultDataset - The data set that holds the cropped results.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing. The object setting is invalid here.

  Returns:

  analysis successful return value is true, failure return value is false.

  Example:

  The following code demonstrates how to crop a line vector dataset.

   public void overlayAnalystClip1() {
          // Returns the vector dataset to be clipped and the vector dataset to be used for clipping
          Workspace workspace = new Workspace();
          String rootPath = android.os.Environment.getExternalStorageDirectory().getAbsolutePath();
          DatasourceConnectionInfo datasourceConnectionInfo = new
                  DatasourceConnectionInfo(rootPath + "/SampleData/shanghai/shanghai.udb",
                                           "shanghai", "");
          Datasource targetDatasource = workspace.getDatasources().open(
                  datasourceConnectionInfo);
          DatasetVector datasetCliped = (DatasetVector) targetDatasource.
                                        getDatasets().get("Road_L");
          DatasetVector datasetClip = (DatasetVector) targetDatasource.
                                      getDatasets().get("Park_R");
  
          // Create a line dataset to save result.
          String resultDatasetClipName = targetDatasource.getDatasets().
                                         getAvailableDatasetName(
                  "resultDatasetClip");
          DatasetVectorInfo datasetvectorInfoClip = new DatasetVectorInfo();
          datasetvectorInfoClip.setType(DatasetType.LINE);
          datasetvectorInfoClip.setName(resultDatasetClipName);
          datasetvectorInfoClip.setEncodeType(EncodeType.NONE);
          DatasetVector resultDatasetClip = targetDatasource.getDatasets().create(
                  datasetvectorInfoClip);
  
          // Sets overlaying parameters
          OverlayAnalystParameter overlayAnalystParamClip = new
                  OverlayAnalystParameter();
          overlayAnalystParamClip.setTolerance(0.0122055608);
  
          // Calls the clip method to achieve the overlay analysis
          OverlayAnalyst.clip(datasetCliped, datasetClip, resultDatasetClip,
                              overlayAnalystParamClip);
  
          // Releases all resource occupied by the workspace
          workspace.dispose();
      }

• clip

  public static boolean clip(Recordset recordset,
                             Recordset clipRecordset,
                             DatasetVector resultDataset,
                             OverlayAnalystParameter parameter)

  Cut the recordset and crop and delete the objects in the second record set that are not in the second record set.

  note:

  1. The type of the clipping record set (second record set) must be a face, and the set of records to be cut (the first recordset) can be points, lines, faces.
  2. In the cut record set, only objects that fall within the clipping record set polygon are output to the result dataset.
  3. Crop the record set, the geographic coordinates of the set of records and the resulting dataset must be consistent.
  4. clip and intersect are consistent in space processing, the difference is that the results of the data set attribute processing, clip analysis is used to do the cut, the result data set with the first data set of the same property table structure, where the superposition Invalid parameter object setting for analysis. And the result of the Intersect cross analysis can preserve the fields of the two data sets according to the field setting.
  5. The results of all overlay analyzes do not take into account the system fields of the recordset.

  For a sketch of the clipping, refer to the description of another overloaded method clip .

  Parameters:

  recordset - The set of records that are cut, also known as the first recordset. The record set type can be point, line and face.

  clipRecordset - The set of records used for cropping, also called the second set of records. The record set type must be a face type.

  resultDataset - The data set that holds the cropped results.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing. The object setting is invalid here.

  Returns:

  The successful return value is true, and the return value is false.

  Example:

  The following code demonstrates how to crop a line record set.

    public void overlayAnalystClip2() {
          // Returns the record set to be clipped and the record set to be used for clipping
          Workspace workspace = new Workspace();
          String rootPath = android.os.Environment.getExternalStorageDirectory().getAbsolutePath();
          DatasourceConnectionInfo datasourceConnectionInfo = new
                  DatasourceConnectionInfo(rootPath + "/SampleData/shanghai/shanghai.udb",
                                           "shanghai", "");
          Datasource targetDatasource = workspace.getDatasources().open(
                  datasourceConnectionInfo);
  
          DatasetVector datasetRoad = (DatasetVector) targetDatasource.
                                      getDatasets().get("Road_L");
          QueryParameter queryParamCliped = new QueryParameter();
          queryParamCliped.setAttributeFilter("ClassID=430110");
          queryParamCliped.setHasGeometry(true);
          Recordset queryResultCliped = datasetRoad.query(queryParamCliped);
  
          DatasetVector datasetPark = (DatasetVector) targetDatasource.
                                      getDatasets().get("Park_R");
          QueryParameter queryParamClip = new QueryParameter();
          queryParamClip.setAttributeFilter("ClassID=370100");
          queryParamClip.setHasGeometry(true);
          Recordset queryResultClip = datasetPark.query(queryParamClip);
  
          // Create a line dataset to save result.
          String resultDatasetClipName = targetDatasource.getDatasets().
                                         getAvailableDatasetName(
                  "resultDatasetClip");
          DatasetVectorInfo datasetvectorInfoClip = new DatasetVectorInfo();
          datasetvectorInfoClip.setType(DatasetType.LINE);
          datasetvectorInfoClip.setName(resultDatasetClipName);
          datasetvectorInfoClip.setEncodeType(EncodeType.NONE);
          DatasetVector resultDatasetClip = targetDatasource.getDatasets().create(
                  datasetvectorInfoClip);
  
          //  Sets overlaying parameters
          OverlayAnalystParameter overlayAnalystParamClip = new
                  OverlayAnalystParameter();
          overlayAnalystParamClip.setTolerance(0.0000015);
  
          // Calls the clip method to achieve the overlay analysis
          OverlayAnalyst.clip(queryResultCliped, queryResultClip,
                              resultDatasetClip, overlayAnalystParamClip);
  
          // Releases all resource occupied by the workspace
          workspace.dispose();
      }

• clip

  public static boolean clip(DatasetVector dataset,
                             Geometry[] clipGeometries,
                             DatasetVector resultDataset,
                             OverlayAnalystParameter parameter)

  The vector dataset is cropped and the objects in the data set that are not in the geometric object array are cropped and deleted.

  1. The type of the cut geometry object must be a face, and the data set to be cut can be a point, a line, a face.
  2. In the cut data set, only objects that fall within the crop geometry will be output to the result dataset.
  3. The array of geometric objects used for cropping, the dataset of the reduced data set, and the geographic coordinates of the resulting dataset must be consistent.
  4. clip and intersect are consistent in space processing, the difference is that the results of the data set attribute processing, clip analysis is used to do the cut, the result data set with the first data set of the same property table structure, where the superposition Invalid parameter setting for analysis. And the result of intersect cross analysis can be based on field settings to retain the two data sets of the field.
  5. All overlay results do not take into account the system fields of the dataset.

  For a sketch of the clipping, refer to the description of another overloaded method clip .

  Parameters:

  dataset - The data set that was dropped. The data set type can be point, line and face.

  clipGeometries - An array of geometric objects used to crop, and the geometric objects in the array must be surface geometry objects.

  resultDataset - The data set that holds the cropped results.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing. The object setting is invalid here.

  Returns:

  analysis returns true on success, false if false.

• erase

  public static boolean erase(DatasetVector dataset,
                              DatasetVector eraseDataset,
                              DatasetVector resultDataset,
                              OverlayAnalystParameter parameter)

  The overlay analysis used to erase the data set, clipping and deleting the objects contained in the second dataset in the first dataset.

  note:

  1. The erasure dataset (the second dataset) must be of a type, and the erased data set (first dataset) can be a point, line, and surface dataset.
  2. Erase the polygon set in the dataset to define the erase area, where the features that fall within these polygons are erased in the erased data set. And the feature elements that fall outside the polygon area are output to the result data set, as opposed to the clip operation.
  3. Erase the dataset, the erasure dataset, and the geographic coordinates of the resulting dataset must be consistent.

  

  Parameters:

  dataset - The data set that was erased, also called the first dataset. The dataset type is point, line, and face type.

  eraseDataset - The data set used to erase, also called the second dataset. The dataset type must be a surface dataset type.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  analysis successful return value is true, failure return value is false.

• erase

  public static boolean erase(Recordset recordset,
                              Recordset eraseRecordset,
                              DatasetVector resultDataset,
                              OverlayAnalystParameter parameter)

  An overlay analysis for erasing the recordset, cutting and deleting the objects contained in the second set of records in the first set of records.

  For a detailed description of the erase, see the description of another overloaded method erase .

  Note: The recordset used for erasure, the erased recordset, and the geographic coordinates of the resulting dataset must be consistent.

  Parameters:

  recordset - is being erased by the recordset, also known as the first recordset. The record set is point, line and face type.

  eraseRecordset - The set of records used to erase, also known as the second record set. The record set type must be a face type.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  analysis successful return value is true, failure return value is false.

• erase

  public static boolean erase(DatasetVector dataset,
                              Geometry[] eraseGeometries,
                              DatasetVector resultDataset,
                              OverlayAnalystParameter parameter)

  The overlay analysis used to erase the data set, cutting the objects contained in the array of geometric objects in the erased data set and deleting them.

  For more information about erase, see the description of another overloaded method erase .

  Note: The array of geometric objects used for erasing, the data sets that are erased, and the geographic coordinates of the resulting dataset must be consistent.

  Parameters:

  dataset - A data set that is erased, which is a point, line, and face type.

  eraseGeometries - An array of geometric objects used to erase, and the geometric objects in the array must be surface geometry objects.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  analysis returns true on success, false if false.

• identity

  public static boolean identity(DatasetVector dataset,
                                 DatasetVector identityDataset,
                                 DatasetVector resultDataset,
                                 OverlayAnalystParameter parameter)

  For the data set in the same way the superposition of the analysis, the results of the data set to keep the same operation of the data set of all objects and the same operation of the data set with the same operation for the intersection of the data set of objects.

  note:

  1. The same operation is the first data set and the second data set first cross, and then cross the results and then the first data set and an operation. Where the type of the second data set must be a face, and the type of the first data set may be a point, a line, a face data set. If the first data set is a point dataset, all objects of the first dataset are retained in the newly generated data set; if the first data set is a line dataset, the first data set is retained in the newly generated data set But if the first data set is a surface dataset, the result dataset retains the first dataset as a control for all polygons within the bounds of the boundary , And the intersection with the second data set in the intersection of the object is divided into multiple objects.
  2. The identity operation has a similarity to the union operation, except that the union operation preserves all parts of the two datasets, and the identity operation is the part of the first data set that does not intersect the second data set To keep it. The result table of the identity operation comes from the attribute table of the two datasets.
  3. The data set for the same operation must be consistent with the same set of data sets and the geographic coordinates of the resulting data set.

  

  Parameters:

  dataset - The data set of the same operation can be point, line, and face type.

  identityDataset - The data set used to perform the same operation must be a face type.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  analysis successful return value is true, failure return value is false.

  Example:

  The overlay analysis of the same method is performed for the two surface datasets.

     public void overlayAnalystIdentity1() {
          // Returns the vector dataset that the indetity operation will be performed on and the vector dataset which will be used for the identity operation.
          Workspace workspace = new Workspace();
          String rootPath = android.os.Environment.getExternalStorageDirectory().getAbsolutePath();
          DatasourceConnectionInfo datasourceConnectionInfo = new
                  DatasourceConnectionInfo(
                  rootPath + "/SampleData/changchun/changchun.udb", "changchun", "");
          Datasource targetDatasource = workspace.getDatasources().open(
                  datasourceConnectionInfo);
          DatasetVector datasetIdentitied = (DatasetVector) targetDatasource.
                                            getDatasets().get("Frame_R");
          DatasetVector datasetIdentity = (DatasetVector) targetDatasource.
                                          getDatasets().get("ResidentialArea");
  
          // Create a region dataset to save result.
          String resultDatasetIdentityName = targetDatasource.getDatasets().
                                             getAvailableDatasetName(
                  "resultDatasetIdentity");
          DatasetVectorInfo datasetvectorInfoIdentity = new DatasetVectorInfo();
          datasetvectorInfoIdentity.setType(DatasetType.REGION);
          datasetvectorInfoIdentity.setName(resultDatasetIdentityName);
          datasetvectorInfoIdentity.setEncodeType(EncodeType.NONE);
          DatasetVector resultDatasetIdentity = targetDatasource.getDatasets().
                                                create(datasetvectorInfoIdentity);
  
          //  Sets overlaying parameters
          OverlayAnalystParameter overlayAnalystParamIdentity = new
                  OverlayAnalystParameter();
          overlayAnalystParamIdentity.setOperationRetainedFields(new String[] {
                  "ClassID"});
          overlayAnalystParamIdentity.setSourceRetainedFields(new String[] {
                  "Name"});
          overlayAnalystParamIdentity.setTolerance(0.0089078724);
  
          // Calls the identity method to achieve the identity operation
          OverlayAnalyst.identity(datasetIdentitied, datasetIdentity,
                               resultDatasetIdentity, overlayAnalystParamIdentity);
  
          // Releases all resource occupied by the workspace
          workspace.dispose();
      }

• identity

  public static boolean identity(Recordset recordset,
                                 Recordset identityRecordset,
                                 DatasetVector resultDataset,
                                 OverlayAnalystParameter parameter)

  For the superposition of the same set of records, the results of the data set to keep the unified operation of the records of all the objects and the same operation of the recordset and the same operation used to record the intersection of the set of objects.

  For a detailed description of the same operation, see the description of another overloaded method identity .

  Note that the recordsets used for the same operation must be consistent with the same set of recordsets and the geographic coordinates of the resulting data set.

  Parameters:

  recordset - The same set of records, also become the first record set, can be point, line, surface type.

  identityRecordset - The set of records used to perform the same operation also becomes the second record set and must be a face type.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  analysis successful return value is true, failure return value is false.

  Example:

  The following code demonstrates the superposition analysis of the same way for two surface recordsets.

     public void overlayAnalystIdentity2() {
          // Returns the record set that the indetity operation will be performed on and the record set which will be used for the identity operation.
          Workspace workspace = new Workspace();
          String rootPath = android.os.Environment.getExternalStorageDirectory().getAbsolutePath();
          DatasourceConnectionInfo datasourceConnectionInfo = new
                  DatasourceConnectionInfo(
                  rootPath + "/SampleData/changchun/changchun.udb", "changchun", "");
          Datasource targetDatasource = workspace.getDatasources().open(
                  datasourceConnectionInfo);
  
          DatasetVector datasetIdentitied = (DatasetVector) targetDatasource.
                                            getDatasets().get("Frame_R");
          Recordset queryResultIdentitied = datasetIdentitied.getRecordset(false,
                  CursorType.DYNAMIC);
  
          DatasetVector datasetIdentity = (DatasetVector) targetDatasource.
                                          getDatasets().get("ResidentialArea");
          QueryParameter queryParamIdentity = new QueryParameter();
          queryParamIdentity.setAttributeFilter("ClassID = 32023");
          queryParamIdentity.setHasGeometry(true);
          Recordset queryResultIdentity = datasetIdentity.query(
                  queryParamIdentity);
  
          // Create a region dataset to save result.
          String resultDatasetIdentityName = targetDatasource.getDatasets().
                                             getAvailableDatasetName(
                  "resultDatasetIdentity");
          DatasetVectorInfo datasetvectorInfoIdentity = new DatasetVectorInfo();
          datasetvectorInfoIdentity.setType(DatasetType.REGION);
          datasetvectorInfoIdentity.setName(resultDatasetIdentityName);
          datasetvectorInfoIdentity.setEncodeType(EncodeType.NONE);
          DatasetVector resultDatasetIdentity = targetDatasource.getDatasets().
                                                create(datasetvectorInfoIdentity);
  
          //  Sets overlaying parameters
          OverlayAnalystParameter overlayAnalystParamIdentity = new
                  OverlayAnalystParameter();
          overlayAnalystParamIdentity.setOperationRetainedFields(new String[] {
                  "ClassID"});
          overlayAnalystParamIdentity.setSourceRetainedFields(new String[] {
                  "Name"});
          overlayAnalystParamIdentity.setTolerance(0.0089078724);
  
          // Calls the identity method to achieve the identity operation
          OverlayAnalyst.identity(queryResultIdentitied, queryResultIdentity,
                               resultDatasetIdentity, overlayAnalystParamIdentity);
  
          // Releases all resource occupied by the workspace
          workspace.dispose();
      }

• identity

  public static boolean identity(DatasetVector dataset,
                                 Geometry[] identityGeometries,
                                 DatasetVector resultDataset,
                                 OverlayAnalystParameter parameter)

  For the data set in the same way the superposition of the analysis, the results of the data set to keep the same operation of the data set of all objects and the same operation of the data set with the same operation for the intersection of geometric object array object.

  For a detailed description of the same operation, see the description of another overloaded method identity .

  Note that the array of geometric objects used for the same operation must be consistent with the same set of data sets and the geographic coordinates of the resulting data set.

  Parameters:

  dataset - The data set of the same operation can be point, line, and face type.

  identityGeometries - An array of geometric objects used to perform the same operation, the geometric objects in the array must be surface geometry objects.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  Returns true if the analysis succeeds, false otherwise.

• intersect

  public static boolean intersect(DatasetVector dataset,
                                  DatasetVector intersectDataset,
                                  DatasetVector resultDataset,
                                  OverlayAnalystParameter parameter)

  The superposition analysis of the intersection mode is performed, and the data sets to be subjected to the intersection superposition analysis are not included in the data set for the data set used to intersect the superimposition analysis to be cut and deleted. That is, the overlapping parts of the two data sets will be output to the result data set and the rest will be excluded.

  note:

  1. The datasets that are analyzed by the intersection overlay can be point types, line types, and face types, and the dataset used to intersect the overlay analysis must be a face type. The feature objects (points, lines, and faces) of the first data set are split at the intersection with the polygons in the second data set (except for the point object), and the split result is output to the result data set.
  2. The intersecting operation is the same as the spatial geometry of the result dataset obtained by the clipping operation, but the cropping operation does not do any processing on the attribute table, and the intersection operator allows the user to select the attribute field that needs to be reserved.
  3. The datasets used for intersecting overlay analysis, the datasets of the intersecting overlay analysis, and the geographic coordinates of the resulting dataset must be consistent.

  

  Parameters:

  dataset - The data set of the dataset can be a point, line, and surface dataset.

  intersectDataset - The dataset used to intersect the overlay analysis, which must be a surface dataset.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  analysis successful return value is true, failure return value is false.

  Example:

  The following code demonstrates a superposition analysis of the intersection of two surface datasets.

   public void overlayAnalystIntersect1() {
          // Returns the intersected vector dataset and the intersecting vector dataset 
          Workspace workspace = new Workspace();
          String rootPath = android.os.Environment.getExternalStorageDirectory().getAbsolutePath();
          DatasourceConnectionInfo datasourceConnectionInfo = new
                  DatasourceConnectionInfo(
                  rootPath + "/SampleData/changchun/changchun.udb", "changchun", "");
          Datasource targetDatasource = workspace.getDatasources().open(
                  datasourceConnectionInfo);
          DatasetVector datasetIntersected = (DatasetVector) targetDatasource.
                                             getDatasets().get("Frame_R");
          DatasetVector datasetIntersect = (DatasetVector) targetDatasource.
                                           getDatasets().get("ResidentialArea");
  
          // Create a region dataset to save result.
          String resultDatasetIntersectName = targetDatasource.getDatasets().
                                              getAvailableDatasetName(
                  "resultDatasetIntersect");
          DatasetVectorInfo datasetvectorInfoIntersect = new DatasetVectorInfo();
          datasetvectorInfoIntersect.setType(DatasetType.REGION);
          datasetvectorInfoIntersect.setName(resultDatasetIntersectName);
          datasetvectorInfoIntersect.setEncodeType(EncodeType.NONE);
          DatasetVector resultDatasetIntersect = targetDatasource.getDatasets().
                                                 create(
                  datasetvectorInfoIntersect);
  
          //  Sets overlaying parameters
          OverlayAnalystParameter overlayAnalystParamIntersect = new
                  OverlayAnalystParameter();
          overlayAnalystParamIntersect.setOperationRetainedFields(new String[] {
                  "ClassID"});
          overlayAnalystParamIntersect.setSourceRetainedFields(new String[] {
                  "Name"});
          overlayAnalystParamIntersect.setTolerance(0.0000011074);
  
          // Calls the intersect method to achieve the intersect analysis
          OverlayAnalyst.intersect(datasetIntersected, datasetIntersect,
                                   resultDatasetIntersect,
                                   overlayAnalystParamIntersect);
  
          // Releases all resource occupied by the workspace
          workspace.dispose();
  
      }

• intersect

  public static boolean intersect(Recordset recordset,
                                  Recordset intersectRecordset,
                                  DatasetVector resultDataset,
                                  OverlayAnalystParameter parameter)

  The superposition analysis of the intersecting mode is performed, and the set of records to be subjected to the intersection superposition analysis is not included in the object set in the recording set for intersecting the superimposition analysis to be cut and deleted.

  For a detailed description of intersecting operations, see the description of another overloaded methodintersect .

  Note that the recordsets used to intersect the overlay analysis, the recordsets that are intersected, and the geographic coordinates of the resulting data set must be consistent.

  Parameters:

  recordset - The set of records that are superimposed by the intersection, which can be point, line, and face types.

  intersectRecordset - The set of records used to intersect the overlay analysis must be surface.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  The successful return value is true, and the return failure value is false.

  Example:

  The following code demonstrates the superposition analysis of the intersection of two faces.

     public void overlayAnalystIntersect2() {
          // Returns the intersected record set and the intersecting record set 
          Workspace workspace = new Workspace();
          String rootPath = android.os.Environment.getExternalStorageDirectory().getAbsolutePath();
          DatasourceConnectionInfo datasourceConnectionInfo = new
                  DatasourceConnectionInfo(
                  rootPath + "/SampleData/changchun/changchun.udb", "changchun", "");
          Datasource targetDatasource = workspace.getDatasources().open(
                  datasourceConnectionInfo);
  
          DatasetVector datasetIntersected = (DatasetVector) targetDatasource.
                                             getDatasets().get("Frame_R");
          Recordset queryResultIntersected = datasetIntersected.getRecordset(false,
                  CursorType.DYNAMIC);
  
          DatasetVector datasetIntersect = (DatasetVector) targetDatasource.
                                           getDatasets().get("ResidentialArea");
          QueryParameter queryParamIntersect = new QueryParameter();
          queryParamIntersect.setAttributeFilter("ClassID = 32023");
          queryParamIntersect.setHasGeometry(true);
          Recordset queryResultIntersect = datasetIntersect.query(
                  queryParamIntersect);
  
          // Create a region dataset to save result.
          String resultDatasetIntersectName = targetDatasource.getDatasets().
                                              getAvailableDatasetName(
                  "resultDatasetIntersect");
          DatasetVectorInfo datasetvectorInfoIntersect = new DatasetVectorInfo();
          datasetvectorInfoIntersect.setType(DatasetType.REGION);
          datasetvectorInfoIntersect.setName(resultDatasetIntersectName);
          datasetvectorInfoIntersect.setEncodeType(EncodeType.NONE);
          DatasetVector resultDatasetIntersect = targetDatasource.getDatasets().
                                                 create(
                  datasetvectorInfoIntersect);
  
          //  Sets overlaying parameters
          OverlayAnalystParameter overlayAnalystParamIntersect = new
                  OverlayAnalystParameter();
          overlayAnalystParamIntersect.setOperationRetainedFields(new String[] {
                  "ClassID"});
          overlayAnalystParamIntersect.setSourceRetainedFields(new String[] {
                  "Name"});
          overlayAnalystParamIntersect.setTolerance(0.0000011074);
  
          // Calls the intersect method to achieve the intersect analysis
          OverlayAnalyst.intersect(queryResultIntersected, queryResultIntersect,
                                   resultDatasetIntersect,
                                   overlayAnalystParamIntersect);
  
          // Releases all resource occupied by the workspace
          workspace.dispose();
      }

• intersect

  public static boolean intersect(DatasetVector dataset,
                                  Geometry[] intersectGeometries,
                                  DatasetVector resultDataset,
                                  OverlayAnalystParameter parameter)

  The superposition analysis of the intersection mode is performed, and the data set to be subjected to the intersection superposition analysis is not included in the object cut-out and deleted by the array of face objects used to intersect the superimposition analysis.

  For a detailed description of intersecting operations, see the description of another overloaded methodintersect .

  Note that the array of face objects for intersecting overlay analysis, the datasets that are intersected, and the geographic coordinates of the resulting dataset must be consistent.

  Parameters:

  dataset - The data set of the dataset can be a point, line, and surface dataset.

  intersectGeometries - The array of face objects used to interpolate overlay analysis.

  resultDataset - The dataset where the analysis results are stored.

  parameter - Overrides the parsed parameter object, which is used to set the parsing parameters such as reserved fields when parsing.

  Returns:

  analysis returns true on success, false if false.

• xOR

  public static boolean xOR(DatasetVector dataset,
                            DatasetVector xORDataset,
                            DatasetVector resultDataset,
                            OverlayAnalystParameter parameter)

  Symmetric difference operation is performed on two surface datasets. That is, the intersection of anti-operation.
• The data set for symmetric difference analysis, the data set of the symmetric difference analysis, and the geographic coordinate system of the resulting data set must be consistent.

  Symmetric difference operation is the exclusive OR operation of two data sets. The result of the operation is that for each face object, the part that intersects the geometric object in another data set is removed, leaving the remainder. The attribute table of the output of the symmetric difference operation contains the non-system attribute fields of the two input data sets.